package com.itboye.sunsun.custome;

import android.content.Context;  
import android.database.DataSetObserver;  
import android.graphics.Canvas;  
import android.graphics.Rect;  
import android.graphics.drawable.Drawable;  
import android.os.Parcel;  
import android.os.Parcelable;  
import android.os.SystemClock;  
import android.support.v4.os.ParcelableCompat;  
import android.support.v4.os.ParcelableCompatCreatorCallbacks;  
import android.support.v4.view.KeyEventCompat;  
import android.support.v4.view.MotionEventCompat;  
import android.support.v4.view.PagerAdapter;  
import android.support.v4.view.VelocityTrackerCompat;  
import android.support.v4.view.ViewCompat;  
import android.support.v4.view.ViewConfigurationCompat;  
import android.support.v4.widget.EdgeEffectCompat;  
import android.util.AttributeSet;  
import android.util.Log;  
import android.view.FocusFinder;  
import android.view.KeyEvent;  
import android.view.MotionEvent;  
import android.view.SoundEffectConstants;  
import android.view.VelocityTracker;  
import android.view.View;  
import android.view.ViewConfiguration;  
import android.view.ViewGroup;  
import android.view.ViewParent;  
import android.view.accessibility.AccessibilityEvent;  
import android.view.animation.Interpolator;  
import android.widget.Scroller;  
  
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
  
/** 
 * Layout manager that allows the user to flip left and right 
 * through pages of data.  You supply an implementation of a 
 * {@link android.support.v4.view.PagerAdapter} to generate the pages that the view shows. 
 * 
 * <p>Note this class is currently under early design and 
 * development.  The API will likely change in later updates of 
 * the compatibility library, requiring changes to the source code 
 * of apps when they are compiled against the newer version.</p> 
 */  
public class NoPreViewPager extends ViewGroup {  
    private static final String TAG = "<span style=\"+font-family:Arial, Helvetica, sans-serif;\">NoPreLoadViewPager</span>";  
    private static final boolean DEBUG = false;  
  
    private static final boolean USE_CACHE = false;  
  
    private static final int DEFAULT_OFFSCREEN_PAGES = 0;//默认是1  
    private static final int MAX_SETTLE_DURATION = 600; // ms  
  
    static class ItemInfo {  
        Object object;  
        int position;  
        boolean scrolling;  
    }  
  
    private static final Comparator<ItemInfo> COMPARATOR = new Comparator<ItemInfo>(){  
        @Override  
        public int compare(ItemInfo lhs, ItemInfo rhs) {  
            return lhs.position - rhs.position;  
        }};  
  
    private static final Interpolator sInterpolator = new Interpolator() {  
        public float getInterpolation(float t) {  
            // _o(t) = t * t * ((tension + 1) * t + tension)  
            // o(t) = _o(t - 1) + 1  
            t -= 1.0f;  
            return t * t * t + 1.0f;  
        }  
    };  
  
    private final ArrayList<ItemInfo> mItems = new ArrayList<ItemInfo>();  
  
    private PagerAdapter mAdapter;  
    private int mCurItem;   // Index of currently displayed page.  
    private int mRestoredCurItem = -1;  
    private Parcelable mRestoredAdapterState = null;  
    private ClassLoader mRestoredClassLoader = null;  
    private Scroller mScroller;  
    private PagerObserver mObserver;  
  
    private int mPageMargin;  
    private Drawable mMarginDrawable;  
  
    private int mChildWidthMeasureSpec;  
    private int mChildHeightMeasureSpec;  
    private boolean mInLayout;  
  
    private boolean mScrollingCacheEnabled;  
  
    private boolean mPopulatePending;  
    private boolean mScrolling;  
    private int mOffscreenPageLimit = DEFAULT_OFFSCREEN_PAGES;  
  
    private boolean mIsBeingDragged;  
    private boolean mIsUnableToDrag;  
    private int mTouchSlop;  
    private float mInitialMotionX;  
    /** 
     * Position of the last motion event. 
     */  
    private float mLastMotionX;  
    private float mLastMotionY;  
    /** 
     * ID of the active pointer. This is used to retain consistency during 
     * drags/flings if multiple pointers are used. 
     */  
    private int mActivePointerId = INVALID_POINTER;  
    /** 
     * Sentinel value for no current active pointer. 
     * Used by {@link #mActivePointerId}. 
     */  
    private static final int INVALID_POINTER = -1;  
  
    /** 
     * Determines speed during touch scrolling 
     */  
    private VelocityTracker mVelocityTracker;  
    private int mMinimumVelocity;  
    private int mMaximumVelocity;  
    private float mBaseLineFlingVelocity;  
    private float mFlingVelocityInfluence;  
  
    private boolean mFakeDragging;  
    private long mFakeDragBeginTime;  
  
    private EdgeEffectCompat mLeftEdge;  
    private EdgeEffectCompat mRightEdge;  
  
    private boolean mFirstLayout = true;  
  
    private OnPageChangeListener mOnPageChangeListener;  
  
    /** 
     * Indicates that the pager is in an idle, settled state. The current page 
     * is fully in view and no animation is in progress. 
     */  
    public static final int SCROLL_STATE_IDLE = 0;  
  
    /** 
     * Indicates that the pager is currently being dragged by the user. 
     */  
    public static final int SCROLL_STATE_DRAGGING = 1;  
  
    /** 
     * Indicates that the pager is in the process of settling to a final position. 
     */  
    public static final int SCROLL_STATE_SETTLING = 2;  
  
    private int mScrollState = SCROLL_STATE_IDLE;  
  
    /** 
     * Callback interface for responding to changing state of the selected page. 
     */  
    public interface OnPageChangeListener {  
  
        /** 
         * This method will be invoked when the current page is scrolled, either as part 
         * of a programmatically initiated smooth scroll or a user initiated touch scroll. 
         * 
         * @param position Position index of the first page currently being displayed. 
         *                 Page position+1 will be visible if positionOffset is nonzero. 
         * @param positionOffset Value from [0, 1) indicating the offset from the page at position. 
         * @param positionOffsetPixels Value in pixels indicating the offset from position. 
         */  
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels);  
  
        /** 
         * This method will be invoked when a new page becomes selected. Animation is not 
         * necessarily complete. 
         * 
         * @param position Position index of the new selected page. 
         */  
        public void onPageSelected(int position);  
  
        /** 
         * Called when the scroll state changes. Useful for discovering when the user 
         * begins dragging, when the pager is automatically settling to the current page, 
         * or when it is fully stopped/idle. 
         * 
         * @param state The new scroll state. 
         * @see android.support.v4.view.ViewPager#SCROLL_STATE_IDLE 
         * @see android.support.v4.view.ViewPager#SCROLL_STATE_DRAGGING 
         * @see android.support.v4.view.ViewPager#SCROLL_STATE_SETTLING 
         */  
        public void onPageScrollStateChanged(int state);  
    }  
  
    /** 
     * Simple implementation of the {@link android.support.v4.view.LazyViewPager.OnPageChangeListener} interface with stub 
     * implementations of each method. Extend this if you do not intend to override 
     * every method of {@link android.support.v4.view.LazyViewPager.OnPageChangeListener}. 
     */  
    public static class SimpleOnPageChangeListener implements OnPageChangeListener {  
        @Override  
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {  
            // This space for rent  
        }  
  
        @Override  
        public void onPageSelected(int position) {  
            // This space for rent  
        }  
  
        @Override  
        public void onPageScrollStateChanged(int state) {  
            // This space for rent  
        }  
    }  
  
    public NoPreViewPager(Context context) {  
        super(context);  
        initViewPager();  
    }  
  
    public NoPreViewPager(Context context, AttributeSet attrs) {  
        super(context, attrs);  
        initViewPager();  
    }  
  
    void initViewPager() {  
        setWillNotDraw(false);  
        setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);  
        setFocusable(true);  
        final Context context = getContext();  
        mScroller = new Scroller(context, sInterpolator);  
        final ViewConfiguration configuration = ViewConfiguration.get(context);  
        mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);  
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();  
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();  
        mLeftEdge = new EdgeEffectCompat(context);  
        mRightEdge = new EdgeEffectCompat(context);  
  
        float density = context.getResources().getDisplayMetrics().density;  
        mBaseLineFlingVelocity = 2500.0f * density;  
        mFlingVelocityInfluence = 0.4f;  
    }  
  
    private void setScrollState(int newState) {  
        if (mScrollState == newState) {  
            return;  
        }  
  
        mScrollState = newState;  
        if (mOnPageChangeListener != null) {  
            mOnPageChangeListener.onPageScrollStateChanged(newState);  
        }  
    }  
  
    public void setAdapter(PagerAdapter adapter) {  
        if (mAdapter != null) {  
//            mAdapter.unregisterDataSetObserver(mObserver);  
            mAdapter.startUpdate(this);  
            for (int i = 0; i < mItems.size(); i++) {  
                final ItemInfo ii = mItems.get(i);  
                mAdapter.destroyItem(this, ii.position, ii.object);  
            }  
            mAdapter.finishUpdate(this);  
            mItems.clear();  
            removeAllViews();  
            mCurItem = 0;  
            scrollTo(0, 0);  
        }  
  
        mAdapter = adapter;  
  
        if (mAdapter != null) {  
            if (mObserver == null) {  
                mObserver = new PagerObserver();  
            }  
//            mAdapter.registerDataSetObserver(mObserver);  
            mPopulatePending = false;  
            if (mRestoredCurItem >= 0) {  
                mAdapter.restoreState(mRestoredAdapterState, mRestoredClassLoader);  
                setCurrentItemInternal(mRestoredCurItem, false, true);  
                mRestoredCurItem = -1;  
                mRestoredAdapterState = null;  
                mRestoredClassLoader = null;  
            } else {  
                populate();  
            }  
        }  
    }  
  
    public PagerAdapter getAdapter() {  
        return mAdapter;  
    }  
  
    /** 
     * Set the currently selected page. If the ViewPager has already been through its first 
     * layout there will be a smooth animated transition between the current item and the 
     * specified item. 
     * 
     * @param item Item index to select 
     */  
    public void setCurrentItem(int item) {  
        mPopulatePending = false;  
        setCurrentItemInternal(item, !mFirstLayout, false);  
    }  
  
    /** 
     * Set the currently selected page. 
     * 
     * @param item Item index to select 
     * @param smoothScroll True to smoothly scroll to the new item, false to transition immediately 
     */  
    public void setCurrentItem(int item, boolean smoothScroll) {  
        mPopulatePending = false;  
        setCurrentItemInternal(item, smoothScroll, false);  
    }  
  
    public int getCurrentItem() {  
        return mCurItem;  
    }  
  
    void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {  
        setCurrentItemInternal(item, smoothScroll, always, 0);  
    }  
  
    void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {  
        if (mAdapter == null || mAdapter.getCount() <= 0) {  
            setScrollingCacheEnabled(false);  
            return;  
        }  
        if (!always && mCurItem == item && mItems.size() != 0) {  
            setScrollingCacheEnabled(false);  
            return;  
        }  
        if (item < 0) {  
            item = 0;  
        } else if (item >= mAdapter.getCount()) {  
            item = mAdapter.getCount() - 1;  
        }  
        final int pageLimit = mOffscreenPageLimit;  
        if (item > (mCurItem + pageLimit) || item < (mCurItem - pageLimit)) {  
            // We are doing a jump by more than one page.  To avoid  
            // glitches, we want to keep all current pages in the view  
            // until the scroll ends.  
            for (int i=0; i<mItems.size(); i++) {  
                mItems.get(i).scrolling = true;  
            }  
        }  
  
        final boolean dispatchSelected = mCurItem != item;  
        mCurItem = item;  
        populate();  
        final int destX = (getWidth() + mPageMargin) * item;  
        if (smoothScroll) {  
            smoothScrollTo(destX, 0, velocity);  
            if (dispatchSelected && mOnPageChangeListener != null) {  
                mOnPageChangeListener.onPageSelected(item);  
            }  
        } else {  
            if (dispatchSelected && mOnPageChangeListener != null) {  
                mOnPageChangeListener.onPageSelected(item);  
            }  
            completeScroll();  
            scrollTo(destX, 0);  
        }  
    }  
  
    public void setOnPageChangeListener(OnPageChangeListener listener) {  
        mOnPageChangeListener = listener;  
    }  
  
    /** 
     * Returns the number of pages that will be retained to either side of the 
     * current page in the view hierarchy in an idle state. Defaults to 1. 
     * 
     * @return How many pages will be kept offscreen on either side 
     * @see #setOffscreenPageLimit(int) 
     */  
    public int getOffscreenPageLimit() {  
        return mOffscreenPageLimit;  
    }  
  
    /** 
     * Set the number of pages that should be retained to either side of the 
     * current page in the view hierarchy in an idle state. Pages beyond this 
     * limit will be recreated from the adapter when needed. 
     * 
     * <p>This is offered as an optimization. If you know in advance the number 
     * of pages you will need to support or have lazy-loading mechanisms in place 
     * on your pages, tweaking this setting can have benefits in perceived smoothness 
     * of paging animations and interaction. If you have a small number of pages (3-4) 
     * that you can keep active all at once, less time will be spent in layout for 
     * newly created view subtrees as the user pages back and forth.</p> 
     * 
     * <p>You should keep this limit low, especially if your pages have complex layouts. 
     * This setting defaults to 1.</p> 
     * 
     * @param limit How many pages will be kept offscreen in an idle state. 
     */  
    public void setOffscreenPageLimit(int limit) {  
        if (limit < DEFAULT_OFFSCREEN_PAGES) {  
            Log.w(TAG, "Requested offscreen page limit " + limit + " too small; defaulting to " +  
                    DEFAULT_OFFSCREEN_PAGES);  
            limit = DEFAULT_OFFSCREEN_PAGES;  
        }  
        if (limit != mOffscreenPageLimit) {  
            mOffscreenPageLimit = limit;  
            populate();  
        }  
    }  
  
    /** 
     * Set the margin between pages. 
     * 
     * @param marginPixels Distance between adjacent pages in pixels 
     * @see #getPageMargin() 
     * @see #setPageMarginDrawable(android.graphics.drawable.Drawable) 
     * @see #setPageMarginDrawable(int) 
     */  
    public void setPageMargin(int marginPixels) {  
        final int oldMargin = mPageMargin;  
        mPageMargin = marginPixels;  
  
        final int width = getWidth();  
        recomputeScrollPosition(width, width, marginPixels, oldMargin);  
  
        requestLayout();  
    }  
  
    /** 
     * Return the margin between pages. 
     * 
     * @return The size of the margin in pixels 
     */  
    public int getPageMargin() {  
        return mPageMargin;  
    }  
  
    /** 
     * Set a drawable that will be used to fill the margin between pages. 
     * 
     * @param d Drawable to display between pages 
     */  
    public void setPageMarginDrawable(Drawable d) {  
        mMarginDrawable = d;  
        if (d != null) refreshDrawableState();  
        setWillNotDraw(d == null);  
        invalidate();  
    }  
  
    /** 
     * Set a drawable that will be used to fill the margin between pages. 
     * 
     * @param resId Resource ID of a drawable to display between pages 
     */  
    public void setPageMarginDrawable(int resId) {  
        setPageMarginDrawable(getContext().getResources().getDrawable(resId));  
    }  
  
    @Override  
    protected boolean verifyDrawable(Drawable who) {  
        return super.verifyDrawable(who) || who == mMarginDrawable;  
    }  
  
    @Override  
    protected void drawableStateChanged() {  
        super.drawableStateChanged();  
        final Drawable d = mMarginDrawable;  
        if (d != null && d.isStateful()) {  
            d.setState(getDrawableState());  
        }  
    }  
  
    // We want the duration of the page snap animation to be influenced by the distance that  
    // the screen has to travel, however, we don't want this duration to be effected in a  
    // purely linear fashion. Instead, we use this method to moderate the effect that the distance  
    // of travel has on the overall snap duration.  
    float distanceInfluenceForSnapDuration(float f) {  
        f -= 0.5f; // center the values about 0.  
        f *= 0.3f * Math.PI / 2.0f;  
        return (float) Math.sin(f);  
    }  
  
    /** 
     * Like {@link android.view.View#scrollBy}, but scroll smoothly instead of immediately. 
     * 
     * @param x the number of pixels to scroll by on the X axis 
     * @param y the number of pixels to scroll by on the Y axis 
     */  
    void smoothScrollTo(int x, int y) {  
        smoothScrollTo(x, y, 0);  
    }  
  
    /** 
     * Like {@link android.view.View#scrollBy}, but scroll smoothly instead of immediately. 
     * 
     * @param x the number of pixels to scroll by on the X axis 
     * @param y the number of pixels to scroll by on the Y axis 
     * @param velocity the velocity associated with a fling, if applicable. (0 otherwise) 
     */  
    void smoothScrollTo(int x, int y, int velocity) {  
        if (getChildCount() == 0) {  
            // Nothing to do.  
            setScrollingCacheEnabled(false);  
            return;  
        }  
        int sx = getScrollX();  
        int sy = getScrollY();  
        int dx = x - sx;  
        int dy = y - sy;  
        if (dx == 0 && dy == 0) {  
            completeScroll();  
            setScrollState(SCROLL_STATE_IDLE);  
            return;  
        }  
  
        setScrollingCacheEnabled(true);  
        mScrolling = true;  
        setScrollState(SCROLL_STATE_SETTLING);  
  
        final float pageDelta = (float) Math.abs(dx) / (getWidth() + mPageMargin);  
        int duration = (int) (pageDelta * 100);  
  
        velocity = Math.abs(velocity);  
        if (velocity > 0) {  
            duration += (duration / (velocity / mBaseLineFlingVelocity)) * mFlingVelocityInfluence;  
        } else {  
            duration += 100;  
        }  
        duration = Math.min(duration, MAX_SETTLE_DURATION);  
  
        mScroller.startScroll(sx, sy, dx, dy, duration);  
        invalidate();  
    }  
  
    void addNewItem(int position, int index) {  
        ItemInfo ii = new ItemInfo();  
        ii.position = position;  
        ii.object = mAdapter.instantiateItem(this, position);  
        if (index < 0) {  
            mItems.add(ii);  
        } else {  
            mItems.add(index, ii);  
        }  
    }  
  
    void dataSetChanged() {  
        // This method only gets called if our observer is attached, so mAdapter is non-null.  
  
        boolean needPopulate = mItems.size() < 3 && mItems.size() < mAdapter.getCount();  
        int newCurrItem = -1;  
  
        for (int i = 0; i < mItems.size(); i++) {  
            final ItemInfo ii = mItems.get(i);  
            final int newPos = mAdapter.getItemPosition(ii.object);  
  
            if (newPos == PagerAdapter.POSITION_UNCHANGED) {  
                continue;  
            }  
  
            if (newPos == PagerAdapter.POSITION_NONE) {  
                mItems.remove(i);  
                i--;  
                mAdapter.destroyItem(this, ii.position, ii.object);  
                needPopulate = true;  
  
                if (mCurItem == ii.position) {  
                    // Keep the current item in the valid range  
                    newCurrItem = Math.max(0, Math.min(mCurItem, mAdapter.getCount() - 1));  
                }  
                continue;  
            }  
  
            if (ii.position != newPos) {  
                if (ii.position == mCurItem) {  
                    // Our current item changed position. Follow it.  
                    newCurrItem = newPos;  
                }  
  
                ii.position = newPos;  
                needPopulate = true;  
            }  
        }  
  
        Collections.sort(mItems, COMPARATOR);  
  
        if (newCurrItem >= 0) {  
            // TODO This currently causes a jump.  
            setCurrentItemInternal(newCurrItem, false, true);  
            needPopulate = true;  
        }  
        if (needPopulate) {  
            populate();  
            requestLayout();  
        }  
    }  
  
    void populate() {  
        if (mAdapter == null) {  
            return;  
        }  
  
        // Bail now if we are waiting to populate.  This is to hold off  
        // on creating views from the time the user releases their finger to  
        // fling to a new position until we have finished the scroll to  
        // that position, avoiding glitches from happening at that point.  
        if (mPopulatePending) {  
            if (DEBUG) Log.i(TAG, "populate is pending, skipping for now...");  
            return;  
        }  
  
        // Also, don't populate until we are attached to a window.  This is to  
        // avoid trying to populate before we have restored our view hierarchy  
        // state and conflicting with what is restored.  
        if (getWindowToken() == null) {  
            return;  
        }  
  
        mAdapter.startUpdate(this);  
  
        final int pageLimit = mOffscreenPageLimit;  
        final int startPos = Math.max(0, mCurItem - pageLimit);  
        final int N = mAdapter.getCount();  
        final int endPos = Math.min(N-1, mCurItem + pageLimit);  
  
        if (DEBUG) Log.v(TAG, "populating: startPos=" + startPos + " endPos=" + endPos);  
  
        // Add and remove pages in the existing list.  
        int lastPos = -1;  
        for (int i=0; i<mItems.size(); i++) {  
            ItemInfo ii = mItems.get(i);  
            if ((ii.position < startPos || ii.position > endPos) && !ii.scrolling) {  
                if (DEBUG) Log.i(TAG, "removing: " + ii.position + " @ " + i);  
                mItems.remove(i);  
                i--;  
                mAdapter.destroyItem(this, ii.position, ii.object);  
            } else if (lastPos < endPos && ii.position > startPos) {  
                // The next item is outside of our range, but we have a gap  
                // between it and the last item where we want to have a page  
                // shown.  Fill in the gap.  
                lastPos++;  
                if (lastPos < startPos) {  
                    lastPos = startPos;  
                }  
                while (lastPos <= endPos && lastPos < ii.position) {  
                    if (DEBUG) Log.i(TAG, "inserting: " + lastPos + " @ " + i);  
                    addNewItem(lastPos, i);  
                    lastPos++;  
                    i++;  
                }  
            }  
            lastPos = ii.position;  
        }  
  
        // Add any new pages we need at the end.  
        lastPos = mItems.size() > 0 ? mItems.get(mItems.size()-1).position : -1;  
        if (lastPos < endPos) {  
            lastPos++;  
            lastPos = lastPos > startPos ? lastPos : startPos;  
            while (lastPos <= endPos) {  
                if (DEBUG) Log.i(TAG, "appending: " + lastPos);  
                addNewItem(lastPos, -1);  
                lastPos++;  
            }  
        }  
  
        if (DEBUG) {  
            Log.i(TAG, "Current page list:");  
            for (int i=0; i<mItems.size(); i++) {  
                Log.i(TAG, "#" + i + ": page " + mItems.get(i).position);  
            }  
        }  
  
        ItemInfo curItem = null;  
        for (int i=0; i<mItems.size(); i++) {  
            if (mItems.get(i).position == mCurItem) {  
                curItem = mItems.get(i);  
                break;  
            }  
        }  
        mAdapter.setPrimaryItem(this, mCurItem, curItem != null ? curItem.object : null);  
  
        mAdapter.finishUpdate(this);  
  
        if (hasFocus()) {  
            View currentFocused = findFocus();  
            ItemInfo ii = currentFocused != null ? infoForAnyChild(currentFocused) : null;  
            if (ii == null || ii.position != mCurItem) {  
                for (int i=0; i<getChildCount(); i++) {  
                    View child = getChildAt(i);  
                    ii = infoForChild(child);  
                    if (ii != null && ii.position == mCurItem) {  
                        if (child.requestFocus(FOCUS_FORWARD)) {  
                            break;  
                        }  
                    }  
                }  
            }  
        }  
    }  
  
    public static class SavedState extends BaseSavedState {  
        int position;  
        Parcelable adapterState;  
        ClassLoader loader;  
  
        public SavedState(Parcelable superState) {  
            super(superState);  
        }  
  
        @Override  
        public void writeToParcel(Parcel out, int flags) {  
            super.writeToParcel(out, flags);  
            out.writeInt(position);  
            out.writeParcelable(adapterState, flags);  
        }  
  
        @Override  
        public String toString() {  
            return "FragmentPager.SavedState{"  
                    + Integer.toHexString(System.identityHashCode(this))  
                    + " position=" + position + "}";  
        }  
  
        public static final Creator<SavedState> CREATOR  
                = ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {  
                    @Override  
                    public SavedState createFromParcel(Parcel in, ClassLoader loader) {  
                        return new SavedState(in, loader);  
                    }  
                    @Override  
                    public SavedState[] newArray(int size) {  
                        return new SavedState[size];  
                    }  
                });  
  
        SavedState(Parcel in, ClassLoader loader) {  
            super(in);  
            if (loader == null) {  
                loader = getClass().getClassLoader();  
            }  
            position = in.readInt();  
            adapterState = in.readParcelable(loader);  
            this.loader = loader;  
        }  
    }  
  
    @Override  
    public Parcelable onSaveInstanceState() {  
        Parcelable superState = super.onSaveInstanceState();  
        SavedState ss = new SavedState(superState);  
        ss.position = mCurItem;  
        if (mAdapter != null) {  
            ss.adapterState = mAdapter.saveState();  
        }  
        return ss;  
    }  
  
    @Override  
    public void onRestoreInstanceState(Parcelable state) {  
        if (!(state instanceof SavedState)) {  
            super.onRestoreInstanceState(state);  
            return;  
        }  
  
        SavedState ss = (SavedState)state;  
        super.onRestoreInstanceState(ss.getSuperState());  
  
        if (mAdapter != null) {  
            mAdapter.restoreState(ss.adapterState, ss.loader);  
            setCurrentItemInternal(ss.position, false, true);  
        } else {  
            mRestoredCurItem = ss.position;  
            mRestoredAdapterState = ss.adapterState;  
            mRestoredClassLoader = ss.loader;  
        }  
    }  
  
    @Override  
    public void addView(View child, int index, LayoutParams params) {  
        if (mInLayout) {  
            addViewInLayout(child, index, params);  
            child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);  
        } else {  
            super.addView(child, index, params);  
        }  
  
        if (USE_CACHE) {  
            if (child.getVisibility() != GONE) {  
                child.setDrawingCacheEnabled(mScrollingCacheEnabled);  
            } else {  
                child.setDrawingCacheEnabled(false);  
            }  
        }  
    }  
  
    ItemInfo infoForChild(View child) {  
        for (int i=0; i<mItems.size(); i++) {  
            ItemInfo ii = mItems.get(i);  
            if (mAdapter.isViewFromObject(child, ii.object)) {  
                return ii;  
            }  
        }  
        return null;  
    }  
  
    ItemInfo infoForAnyChild(View child) {  
        ViewParent parent;  
        while ((parent=child.getParent()) != this) {  
            if (parent == null || !(parent instanceof View)) {  
                return null;  
            }  
            child = (View)parent;  
        }  
        return infoForChild(child);  
    }  
  
    @Override  
    protected void onAttachedToWindow() {  
        super.onAttachedToWindow();  
        mFirstLayout = true;  
    }  
  
    @Override  
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
        // For simple implementation, or internal size is always 0.  
        // We depend on the container to specify the layout size of  
        // our view.  We can't really know what it is since we will be  
        // adding and removing different arbitrary views and do not  
        // want the layout to change as this happens.  
        setMeasuredDimension(getDefaultSize(0, widthMeasureSpec),  
                getDefaultSize(0, heightMeasureSpec));  
  
        // Children are just made to fill our space.  
        mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -  
                getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY);  
        mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -  
                getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY);  
  
        // Make sure we have created all fragments that we need to have shown.  
        mInLayout = true;  
        populate();  
        mInLayout = false;  
  
        // Make sure all children have been properly measured.  
        final int size = getChildCount();  
        for (int i = 0; i < size; ++i) {  
            final View child = getChildAt(i);  
            if (child.getVisibility() != GONE) {  
                if (DEBUG) Log.v(TAG, "Measuring #" + i + " " + child  
                + ": " + mChildWidthMeasureSpec);  
                child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);  
            }  
        }  
    }  
  
    @Override  
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
        super.onSizeChanged(w, h, oldw, oldh);  
  
        // Make sure scroll position is set correctly.  
        if (w != oldw) {  
            recomputeScrollPosition(w, oldw, mPageMargin, mPageMargin);  
        }  
    }  
  
    private void recomputeScrollPosition(int width, int oldWidth, int margin, int oldMargin) {  
        final int widthWithMargin = width + margin;  
        if (oldWidth > 0) {  
            final int oldScrollPos = getScrollX();  
            final int oldwwm = oldWidth + oldMargin;  
            final int oldScrollItem = oldScrollPos / oldwwm;  
            final float scrollOffset = (float) (oldScrollPos % oldwwm) / oldwwm;  
            final int scrollPos = (int) ((oldScrollItem + scrollOffset) * widthWithMargin);  
            scrollTo(scrollPos, getScrollY());  
            if (!mScroller.isFinished()) {  
                // We now return to your regularly scheduled scroll, already in progress.  
                final int newDuration = mScroller.getDuration() - mScroller.timePassed();  
                mScroller.startScroll(scrollPos, 0, mCurItem * widthWithMargin, 0, newDuration);  
            }  
        } else {  
            int scrollPos = mCurItem * widthWithMargin;  
            if (scrollPos != getScrollX()) {  
                completeScroll();  
                scrollTo(scrollPos, getScrollY());  
            }  
        }  
    }  
  
    @Override  
    protected void onLayout(boolean changed, int l, int t, int r, int b) {  
        mInLayout = true;  
        populate();  
        mInLayout = false;  
  
        final int count = getChildCount();  
        final int width = r-l;  
  
        for (int i = 0; i < count; i++) {  
            View child = getChildAt(i);  
            ItemInfo ii;  
            if (child.getVisibility() != GONE && (ii=infoForChild(child)) != null) {  
                int loff = (width + mPageMargin) * ii.position;  
                int childLeft = getPaddingLeft() + loff;  
                int childTop = getPaddingTop();  
                if (DEBUG) Log.v(TAG, "Positioning #" + i + " " + child + " f=" + ii.object  
                + ":" + childLeft + "," + childTop + " " + child.getMeasuredWidth()  
                + "x" + child.getMeasuredHeight());  
                child.layout(childLeft, childTop,  
                        childLeft + child.getMeasuredWidth(),  
                        childTop + child.getMeasuredHeight());  
            }  
        }  
        mFirstLayout = false;  
    }  
  
    @Override  
    public void computeScroll() {  
        if (DEBUG) Log.i(TAG, "computeScroll: finished=" + mScroller.isFinished());  
        if (!mScroller.isFinished()) {  
            if (mScroller.computeScrollOffset()) {  
                if (DEBUG) Log.i(TAG, "computeScroll: still scrolling");  
                int oldX = getScrollX();  
                int oldY = getScrollY();  
                int x = mScroller.getCurrX();  
                int y = mScroller.getCurrY();  
  
                if (oldX != x || oldY != y) {  
                    scrollTo(x, y);  
                }  
  
                if (mOnPageChangeListener != null) {  
                    final int widthWithMargin = getWidth() + mPageMargin;  
                    final int position = x / widthWithMargin;  
                    final int offsetPixels = x % widthWithMargin;  
                    final float offset = (float) offsetPixels / widthWithMargin;  
                    mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);  
                }  
  
                // Keep on drawing until the animation has finished.  
                invalidate();  
                return;  
            }  
        }  
  
        // Done with scroll, clean up state.  
        completeScroll();  
    }  
  
    private void completeScroll() {  
        boolean needPopulate = mScrolling;  
        if (needPopulate) {  
            // Done with scroll, no longer want to cache view drawing.  
            setScrollingCacheEnabled(false);  
            mScroller.abortAnimation();  
            int oldX = getScrollX();  
            int oldY = getScrollY();  
            int x = mScroller.getCurrX();  
            int y = mScroller.getCurrY();  
            if (oldX != x || oldY != y) {  
                scrollTo(x, y);  
            }  
            setScrollState(SCROLL_STATE_IDLE);  
        }  
        mPopulatePending = false;  
        mScrolling = false;  
        for (int i=0; i<mItems.size(); i++) {  
            ItemInfo ii = mItems.get(i);  
            if (ii.scrolling) {  
                needPopulate = true;  
                ii.scrolling = false;  
            }  
        }  
        if (needPopulate) {  
            populate();  
        }  
    }  
  
    @Override  
    public boolean onInterceptTouchEvent(MotionEvent ev) {  
        /* 
         * This method JUST determines whether we want to intercept the motion. 
         * If we return true, onMotionEvent will be called and we do the actual 
         * scrolling there. 
         */  
  
        final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;  
  
        // Always take care of the touch gesture being complete.  
        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {  
            // Release the drag.  
            if (DEBUG) Log.v(TAG, "Intercept done!");  
            mIsBeingDragged = false;  
            mIsUnableToDrag = false;  
            mActivePointerId = INVALID_POINTER;  
            return false;  
        }  
  
        // Nothing more to do here if we have decided whether or not we  
        // are dragging.  
        if (action != MotionEvent.ACTION_DOWN) {  
            if (mIsBeingDragged) {  
                if (DEBUG) Log.v(TAG, "Intercept returning true!");  
                return true;  
            }  
            if (mIsUnableToDrag) {  
                if (DEBUG) Log.v(TAG, "Intercept returning false!");  
                return false;  
            }  
        }  
  
        switch (action) {  
            case MotionEvent.ACTION_MOVE: {  
                /* 
                 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 
                 * whether the user has moved far enough from his original down touch. 
                 */  
  
                /* 
                * Locally do absolute value. mLastMotionY is set to the y value 
                * of the down event. 
                */  
                final int activePointerId = mActivePointerId;  
                if (activePointerId == INVALID_POINTER) {  
                    // If we don't have a valid id, the touch down wasn't on content.  
                    break;  
                }  
  
                final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);  
                final float x = MotionEventCompat.getX(ev, pointerIndex);  
                final float dx = x - mLastMotionX;  
                final float xDiff = Math.abs(dx);  
                final float y = MotionEventCompat.getY(ev, pointerIndex);  
                final float yDiff = Math.abs(y - mLastMotionY);  
                final int scrollX = getScrollX();  
                final boolean atEdge = (dx > 0 && scrollX == 0) || (dx < 0 && mAdapter != null &&  
                        scrollX >= (mAdapter.getCount() - 1) * getWidth() - 1);  
                if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);  
  
                if (canScroll(this, false, (int) dx, (int) x, (int) y)) {  
                    // Nested view has scrollable area under this point. Let it be handled there.  
                    mInitialMotionX = mLastMotionX = x;  
                    mLastMotionY = y;  
                    return false;  
                }  
                if (xDiff > mTouchSlop && xDiff > yDiff) {  
                    if (DEBUG) Log.v(TAG, "Starting drag!");  
                    mIsBeingDragged = true;  
                    setScrollState(SCROLL_STATE_DRAGGING);  
                    mLastMotionX = x;  
                    setScrollingCacheEnabled(true);  
                } else {  
                    if (yDiff > mTouchSlop) {  
                        // The finger has moved enough in the vertical  
                        // direction to be counted as a drag...  abort  
                        // any attempt to drag horizontally, to work correctly  
                        // with children that have scrolling containers.  
                        if (DEBUG) Log.v(TAG, "Starting unable to drag!");  
                        mIsUnableToDrag = true;  
                    }  
                }  
                break;  
            }  
  
            case MotionEvent.ACTION_DOWN: {  
                /* 
                 * Remember location of down touch. 
                 * ACTION_DOWN always refers to pointer index 0. 
                 */  
                mLastMotionX = mInitialMotionX = ev.getX();  
                mLastMotionY = ev.getY();  
                mActivePointerId = MotionEventCompat.getPointerId(ev, 0);  
  
                if (mScrollState == SCROLL_STATE_SETTLING) {  
                    // Let the user 'catch' the pager as it animates.  
                    mIsBeingDragged = true;  
                    mIsUnableToDrag = false;  
                    setScrollState(SCROLL_STATE_DRAGGING);  
                } else {  
                    completeScroll();  
                    mIsBeingDragged = false;  
                    mIsUnableToDrag = false;  
                }  
  
                if (DEBUG) Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY  
                        + " mIsBeingDragged=" + mIsBeingDragged  
                        + "mIsUnableToDrag=" + mIsUnableToDrag);  
                break;  
            }  
  
            case MotionEventCompat.ACTION_POINTER_UP:  
                onSecondaryPointerUp(ev);  
                break;  
        }  
  
        /* 
        * The only time we want to intercept motion events is if we are in the 
        * drag mode. 
        */  
        return mIsBeingDragged;  
    }  
  
    @Override  
    public boolean onTouchEvent(MotionEvent ev) {  
        if (mFakeDragging) {  
            // A fake drag is in progress already, ignore this real one  
            // but still eat the touch events.  
            // (It is likely that the user is multi-touching the screen.)  
            return true;  
        }  
  
        if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {  
            // Don't handle edge touches immediately -- they may actually belong to one of our  
            // descendants.  
            return false;  
        }  
  
        if (mAdapter == null || mAdapter.getCount() == 0) {  
            // Nothing to present or scroll; nothing to touch.  
            return false;  
        }  
  
        if (mVelocityTracker == null) {  
            mVelocityTracker = VelocityTracker.obtain();  
        }  
        mVelocityTracker.addMovement(ev);  
  
        final int action = ev.getAction();  
        boolean needsInvalidate = false;  
  
        switch (action & MotionEventCompat.ACTION_MASK) {  
            case MotionEvent.ACTION_DOWN: {  
                /* 
                 * If being flinged and user touches, stop the fling. isFinished 
                 * will be false if being flinged. 
                 */  
                completeScroll();  
  
                // Remember where the motion event started  
                mLastMotionX = mInitialMotionX = ev.getX();  
                mActivePointerId = MotionEventCompat.getPointerId(ev, 0);  
                break;  
            }  
            case MotionEvent.ACTION_MOVE:  
                if (!mIsBeingDragged) {  
                    final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);  
                    final float x = MotionEventCompat.getX(ev, pointerIndex);  
                    final float xDiff = Math.abs(x - mLastMotionX);  
                    final float y = MotionEventCompat.getY(ev, pointerIndex);  
                    final float yDiff = Math.abs(y - mLastMotionY);  
                    if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);  
                    if (xDiff > mTouchSlop && xDiff > yDiff) {  
                        if (DEBUG) Log.v(TAG, "Starting drag!");  
                        mIsBeingDragged = true;  
                        mLastMotionX = x;  
                        setScrollState(SCROLL_STATE_DRAGGING);  
                        setScrollingCacheEnabled(true);  
                    }  
                }  
                if (mIsBeingDragged) {  
                    // Scroll to follow the motion event  
                    final int activePointerIndex = MotionEventCompat.findPointerIndex(  
                            ev, mActivePointerId);  
                    final float x = MotionEventCompat.getX(ev, activePointerIndex);  
                    final float deltaX = mLastMotionX - x;  
                    mLastMotionX = x;  
                    float oldScrollX = getScrollX();  
                    float scrollX = oldScrollX + deltaX;  
                    final int width = getWidth();  
                    final int widthWithMargin = width + mPageMargin;  
  
                    final int lastItemIndex = mAdapter.getCount() - 1;  
                    final float leftBound = Math.max(0, (mCurItem - 1) * widthWithMargin);  
                    final float rightBound =  
                            Math.min(mCurItem + 1, lastItemIndex) * widthWithMargin;  
                    if (scrollX < leftBound) {  
                        if (leftBound == 0) {  
                            float over = -scrollX;  
                            needsInvalidate = mLeftEdge.onPull(over / width);  
                        }  
                        scrollX = leftBound;  
                    } else if (scrollX > rightBound) {  
                        if (rightBound == lastItemIndex * widthWithMargin) {  
                            float over = scrollX - rightBound;  
                            needsInvalidate = mRightEdge.onPull(over / width);  
                        }  
                        scrollX = rightBound;  
                    }  
                    // Don't lose the rounded component  
                    mLastMotionX += scrollX - (int) scrollX;  
                    scrollTo((int) scrollX, getScrollY());  
                    if (mOnPageChangeListener != null) {  
                        final int position = (int) scrollX / widthWithMargin;  
                        final int positionOffsetPixels = (int) scrollX % widthWithMargin;  
                        final float positionOffset = (float) positionOffsetPixels / widthWithMargin;  
                        mOnPageChangeListener.onPageScrolled(position, positionOffset,  
                                positionOffsetPixels);  
                    }  
                }  
                break;  
            case MotionEvent.ACTION_UP:  
                if (mIsBeingDragged) {  
                    final VelocityTracker velocityTracker = mVelocityTracker;  
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);  
                    int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(  
                            velocityTracker, mActivePointerId);  
                    mPopulatePending = true;  
                    final int widthWithMargin = getWidth() + mPageMargin;  
                    final int scrollX = getScrollX();  
                    final int currentPage = scrollX / widthWithMargin;  
                    int nextPage = initialVelocity > 0 ? currentPage : currentPage + 1;  
                    setCurrentItemInternal(nextPage, true, true, initialVelocity);  
  
                    mActivePointerId = INVALID_POINTER;  
                    endDrag();  
                    needsInvalidate = mLeftEdge.onRelease() | mRightEdge.onRelease();  
                }  
                break;  
            case MotionEvent.ACTION_CANCEL:  
                if (mIsBeingDragged) {  
                    setCurrentItemInternal(mCurItem, true, true);  
                    mActivePointerId = INVALID_POINTER;  
                    endDrag();  
                    needsInvalidate = mLeftEdge.onRelease() | mRightEdge.onRelease();  
                }  
                break;  
            case MotionEventCompat.ACTION_POINTER_DOWN: {  
                final int index = MotionEventCompat.getActionIndex(ev);  
                final float x = MotionEventCompat.getX(ev, index);  
                mLastMotionX = x;  
                mActivePointerId = MotionEventCompat.getPointerId(ev, index);  
                break;  
            }  
            case MotionEventCompat.ACTION_POINTER_UP:  
                onSecondaryPointerUp(ev);  
                mLastMotionX = MotionEventCompat.getX(ev,  
                        MotionEventCompat.findPointerIndex(ev, mActivePointerId));  
                break;  
        }  
        if (needsInvalidate) {  
            invalidate();  
        }  
        return true;  
    }  
  
    @Override  
    public void draw(Canvas canvas) {  
        super.draw(canvas);  
        boolean needsInvalidate = false;  
  
        final int overScrollMode = ViewCompat.getOverScrollMode(this);  
        if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS ||  
                (overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS &&  
                        mAdapter != null && mAdapter.getCount() > 1)) {  
            if (!mLeftEdge.isFinished()) {  
                final int restoreCount = canvas.save();  
                final int height = getHeight() - getPaddingTop() - getPaddingBottom();  
  
                canvas.rotate(270);  
                canvas.translate(-height + getPaddingTop(), 0);  
                mLeftEdge.setSize(height, getWidth());  
                needsInvalidate |= mLeftEdge.draw(canvas);  
                canvas.restoreToCount(restoreCount);  
            }  
            if (!mRightEdge.isFinished()) {  
                final int restoreCount = canvas.save();  
                final int width = getWidth();  
                final int height = getHeight() - getPaddingTop() - getPaddingBottom();  
                final int itemCount = mAdapter != null ? mAdapter.getCount() : 1;  
  
                canvas.rotate(90);  
                canvas.translate(-getPaddingTop(),  
                        -itemCount * (width + mPageMargin) + mPageMargin);  
                mRightEdge.setSize(height, width);  
                needsInvalidate |= mRightEdge.draw(canvas);  
                canvas.restoreToCount(restoreCount);  
            }  
        } else {  
            mLeftEdge.finish();  
            mRightEdge.finish();  
        }  
  
        if (needsInvalidate) {  
            // Keep animating  
            invalidate();  
        }  
    }  
  
    @Override  
    protected void onDraw(Canvas canvas) {  
        super.onDraw(canvas);  
  
        // Draw the margin drawable if needed.  
        if (mPageMargin > 0 && mMarginDrawable != null) {  
            final int scrollX = getScrollX();  
            final int width = getWidth();  
            final int offset = scrollX % (width + mPageMargin);  
            if (offset != 0) {  
                // Pages fit completely when settled; we only need to draw when in between  
                final int left = scrollX - offset + width;  
                mMarginDrawable.setBounds(left, 0, left + mPageMargin, getHeight());  
                mMarginDrawable.draw(canvas);  
            }  
        }  
    }  
  
    /** 
     * Start a fake drag of the pager. 
     * 
     * <p>A fake drag can be useful if you want to synchronize the motion of the ViewPager 
     * with the touch scrolling of another view, while still letting the ViewPager 
     * control the snapping motion and fling behavior. (e.g. parallax-scrolling tabs.) 
     * Call {@link #fakeDragBy(float)} to simulate the actual drag motion. Call 
     * {@link #endFakeDrag()} to complete the fake drag and fling as necessary. 
     * 
     * <p>During a fake drag the ViewPager will ignore all touch events. If a real drag 
     * is already in progress, this method will return false. 
     * 
     * @return true if the fake drag began successfully, false if it could not be started. 
     * 
     * @see #fakeDragBy(float) 
     * @see #endFakeDrag() 
     */  
    public boolean beginFakeDrag() {  
        if (mIsBeingDragged) {  
            return false;  
        }  
        mFakeDragging = true;  
        setScrollState(SCROLL_STATE_DRAGGING);  
        mInitialMotionX = mLastMotionX = 0;  
        if (mVelocityTracker == null) {  
            mVelocityTracker = VelocityTracker.obtain();  
        } else {  
            mVelocityTracker.clear();  
        }  
        final long time = SystemClock.uptimeMillis();  
        final MotionEvent ev = MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN, 0, 0, 0);  
        mVelocityTracker.addMovement(ev);  
        ev.recycle();  
        mFakeDragBeginTime = time;  
        return true;  
    }  
  
    /** 
     * End a fake drag of the pager. 
     * 
     * @see #beginFakeDrag() 
     * @see #fakeDragBy(float) 
     */  
    public void endFakeDrag() {  
        if (!mFakeDragging) {  
            throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first.");  
        }  
  
        final VelocityTracker velocityTracker = mVelocityTracker;  
        velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);  
        int initialVelocity = (int)VelocityTrackerCompat.getYVelocity(  
                velocityTracker, mActivePointerId);  
        mPopulatePending = true;  
        if ((Math.abs(initialVelocity) > mMinimumVelocity)  
                || Math.abs(mInitialMotionX-mLastMotionX) >= (getWidth()/3)) {  
            if (mLastMotionX > mInitialMotionX) {  
                setCurrentItemInternal(mCurItem-1, true, true);  
            } else {  
                setCurrentItemInternal(mCurItem+1, true, true);  
            }  
        } else {  
            setCurrentItemInternal(mCurItem, true, true);  
        }  
        endDrag();  
  
        mFakeDragging = false;  
    }  
  
    /** 
     * Fake drag by an offset in pixels. You must have called {@link #beginFakeDrag()} first. 
     * 
     * @param xOffset Offset in pixels to drag by. 
     * @see #beginFakeDrag() 
     * @see #endFakeDrag() 
     */  
    public void fakeDragBy(float xOffset) {  
        if (!mFakeDragging) {  
            throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first.");  
        }  
  
        mLastMotionX += xOffset;  
        float scrollX = getScrollX() - xOffset;  
        final int width = getWidth();  
        final int widthWithMargin = width + mPageMargin;  
  
        final float leftBound = Math.max(0, (mCurItem - 1) * widthWithMargin);  
        final float rightBound =  
                Math.min(mCurItem + 1, mAdapter.getCount() - 1) * widthWithMargin;  
        if (scrollX < leftBound) {  
            scrollX = leftBound;  
        } else if (scrollX > rightBound) {  
            scrollX = rightBound;  
        }  
        // Don't lose the rounded component  
        mLastMotionX += scrollX - (int) scrollX;  
        scrollTo((int) scrollX, getScrollY());  
        if (mOnPageChangeListener != null) {  
            final int position = (int) scrollX / widthWithMargin;  
            final int positionOffsetPixels = (int) scrollX % widthWithMargin;  
            final float positionOffset = (float) positionOffsetPixels / widthWithMargin;  
            mOnPageChangeListener.onPageScrolled(position, positionOffset,  
                    positionOffsetPixels);  
        }  
  
        // Synthesize an event for the VelocityTracker.  
        final long time = SystemClock.uptimeMillis();  
        final MotionEvent ev = MotionEvent.obtain(mFakeDragBeginTime, time, MotionEvent.ACTION_MOVE,  
                mLastMotionX, 0, 0);  
        mVelocityTracker.addMovement(ev);  
        ev.recycle();  
    }  
  
    /** 
     * Returns true if a fake drag is in progress. 
     * 
     * @return true if currently in a fake drag, false otherwise. 
     * 
     * @see #beginFakeDrag() 
     * @see #fakeDragBy(float) 
     * @see #endFakeDrag() 
     */  
    public boolean isFakeDragging() {  
        return mFakeDragging;  
    }  
  
    private void onSecondaryPointerUp(MotionEvent ev) {  
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);  
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);  
        if (pointerId == mActivePointerId) {  
            // This was our active pointer going up. Choose a new  
            // active pointer and adjust accordingly.  
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;  
            mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);  
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);  
            if (mVelocityTracker != null) {  
                mVelocityTracker.clear();  
            }  
        }  
    }  
  
    private void endDrag() {  
        mIsBeingDragged = false;  
        mIsUnableToDrag = false;  
  
        if (mVelocityTracker != null) {  
            mVelocityTracker.recycle();  
            mVelocityTracker = null;  
        }  
    }  
  
    private void setScrollingCacheEnabled(boolean enabled) {  
        if (mScrollingCacheEnabled != enabled) {  
            mScrollingCacheEnabled = enabled;  
            if (USE_CACHE) {  
                final int size = getChildCount();  
                for (int i = 0; i < size; ++i) {  
                    final View child = getChildAt(i);  
                    if (child.getVisibility() != GONE) {  
                        child.setDrawingCacheEnabled(enabled);  
                    }  
                }  
            }  
        }  
    }  
  
    /** 
     * Tests scrollability within child views of v given a delta of dx. 
     * 
     * @param v View to test for horizontal scrollability 
     * @param checkV Whether the view v passed should itself be checked for scrollability (true), 
     *               or just its children (false). 
     * @param dx Delta scrolled in pixels 
     * @param x X coordinate of the active touch point 
     * @param y Y coordinate of the active touch point 
     * @return true if child views of v can be scrolled by delta of dx. 
     */  
    protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) {  
        if (v instanceof ViewGroup) {  
            final ViewGroup group = (ViewGroup) v;  
            final int scrollX = v.getScrollX();  
            final int scrollY = v.getScrollY();  
            final int count = group.getChildCount();  
            // Count backwards - let topmost views consume scroll distance first.  
            for (int i = count - 1; i >= 0; i--) {  
                // TODO: Add versioned support here for transformed views.  
                // This will not work for transformed views in Honeycomb+  
                final View child = group.getChildAt(i);  
                if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() &&  
                        y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&  
                        canScroll(child, true, dx, x + scrollX - child.getLeft(),  
                                y + scrollY - child.getTop())) {  
                    return true;  
                }  
            }  
        }  
  
        return checkV && ViewCompat.canScrollHorizontally(v, -dx);  
    }  
  
    @Override  
    public boolean dispatchKeyEvent(KeyEvent event) {  
        // Let the focused view and/or our descendants get the key first  
        return super.dispatchKeyEvent(event) || executeKeyEvent(event);  
    }  
  
    /** 
     * You can call this function yourself to have the scroll view perform 
     * scrolling from a key event, just as if the event had been dispatched to 
     * it by the view hierarchy. 
     * 
     * @param event The key event to execute. 
     * @return Return true if the event was handled, else false. 
     */  
    public boolean executeKeyEvent(KeyEvent event) {  
        boolean handled = false;  
        if (event.getAction() == KeyEvent.ACTION_DOWN) {  
            switch (event.getKeyCode()) {  
                case KeyEvent.KEYCODE_DPAD_LEFT:  
                    handled = arrowScroll(FOCUS_LEFT);  
                    break;  
                case KeyEvent.KEYCODE_DPAD_RIGHT:  
                    handled = arrowScroll(FOCUS_RIGHT);  
                    break;  
                case KeyEvent.KEYCODE_TAB:  
                    if (KeyEventCompat.hasNoModifiers(event)) {  
                        handled = arrowScroll(FOCUS_FORWARD);  
                    } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {  
                        handled = arrowScroll(FOCUS_BACKWARD);  
                    }  
                    break;  
            }  
        }  
        return handled;  
    }  
  
    public boolean arrowScroll(int direction) {  
        View currentFocused = findFocus();  
        if (currentFocused == this) currentFocused = null;  
  
        boolean handled = false;  
  
        View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused,  
                direction);  
        if (nextFocused != null && nextFocused != currentFocused) {  
            if (direction == View.FOCUS_LEFT) {  
                // If there is nothing to the left, or this is causing us to  
                // jump to the right, then what we really want to do is page left.  
                if (currentFocused != null && nextFocused.getLeft() >= currentFocused.getLeft()) {  
                    handled = pageLeft();  
                } else {  
                    handled = nextFocused.requestFocus();  
                }  
            } else if (direction == View.FOCUS_RIGHT) {  
                // If there is nothing to the right, or this is causing us to  
                // jump to the left, then what we really want to do is page right.  
                if (currentFocused != null && nextFocused.getLeft() <= currentFocused.getLeft()) {  
                    handled = pageRight();  
                } else {  
                    handled = nextFocused.requestFocus();  
                }  
            }  
        } else if (direction == FOCUS_LEFT || direction == FOCUS_BACKWARD) {  
            // Trying to move left and nothing there; try to page.  
            handled = pageLeft();  
        } else if (direction == FOCUS_RIGHT || direction == FOCUS_FORWARD) {  
            // Trying to move right and nothing there; try to page.  
            handled = pageRight();  
        }  
        if (handled) {  
            playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));  
        }  
        return handled;  
    }  
  
    boolean pageLeft() {  
        if (mCurItem > 0) {  
            setCurrentItem(mCurItem-1, true);  
            return true;  
        }  
        return false;  
    }  
  
    boolean pageRight() {  
        if (mAdapter != null && mCurItem < (mAdapter.getCount()-1)) {  
            setCurrentItem(mCurItem+1, true);  
            return true;  
        }  
        return false;  
    }  
  
    /** 
     * We only want the current page that is being shown to be focusable. 
     */  
    @Override  
    public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {  
        final int focusableCount = views.size();  
  
        final int descendantFocusability = getDescendantFocusability();  
  
        if (descendantFocusability != FOCUS_BLOCK_DESCENDANTS) {  
            for (int i = 0; i < getChildCount(); i++) {  
                final View child = getChildAt(i);  
                if (child.getVisibility() == VISIBLE) {  
                    ItemInfo ii = infoForChild(child);  
                    if (ii != null && ii.position == mCurItem) {  
                        child.addFocusables(views, direction, focusableMode);  
                    }  
                }  
            }  
        }  
  
        // we add ourselves (if focusable) in all cases except for when we are  
        // FOCUS_AFTER_DESCENDANTS and there are some descendants focusable.  this is  
        // to avoid the focus search finding layouts when a more precise search  
        // among the focusable children would be more interesting.  
        if (  
            descendantFocusability != FOCUS_AFTER_DESCENDANTS ||  
                // No focusable descendants  
                (focusableCount == views.size())) {  
            // Note that we can't call the superclass here, because it will  
            // add all views in.  So we need to do the same thing View does.  
            if (!isFocusable()) {  
                return;  
            }  
            if ((focusableMode & FOCUSABLES_TOUCH_MODE) == FOCUSABLES_TOUCH_MODE &&  
                    isInTouchMode() && !isFocusableInTouchMode()) {  
                return;  
            }  
            if (views != null) {  
                views.add(this);  
            }  
        }  
    }  
  
    /** 
     * We only want the current page that is being shown to be touchable. 
     */  
    @Override  
    public void addTouchables(ArrayList<View> views) {  
        // Note that we don't call super.addTouchables(), which means that  
        // we don't call View.addTouchables().  This is okay because a ViewPager  
        // is itself not touchable.  
        for (int i = 0; i < getChildCount(); i++) {  
            final View child = getChildAt(i);  
            if (child.getVisibility() == VISIBLE) {  
                ItemInfo ii = infoForChild(child);  
                if (ii != null && ii.position == mCurItem) {  
                    child.addTouchables(views);  
                }  
            }  
        }  
    }  
  
    /** 
     * We only want the current page that is being shown to be focusable. 
     */  
    @Override  
    protected boolean onRequestFocusInDescendants(int direction,  
            Rect previouslyFocusedRect) {  
        int index;  
        int increment;  
        int end;  
        int count = getChildCount();  
        if ((direction & FOCUS_FORWARD) != 0) {  
            index = 0;  
            increment = 1;  
            end = count;  
        } else {  
            index = count - 1;  
            increment = -1;  
            end = -1;  
        }  
        for (int i = index; i != end; i += increment) {  
            View child = getChildAt(i);  
            if (child.getVisibility() == VISIBLE) {  
                ItemInfo ii = infoForChild(child);  
                if (ii != null && ii.position == mCurItem) {  
                    if (child.requestFocus(direction, previouslyFocusedRect)) {  
                        return true;  
                    }  
                }  
            }  
        }  
        return false;  
    }  
  
    @Override  
    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {  
        // ViewPagers should only report accessibility info for the current page,  
        // otherwise things get very confusing.  
  
        // TODO: Should this note something about the paging container?  
  
        final int childCount = getChildCount();  
        for (int i = 0; i < childCount; i++) {  
            final View child = getChildAt(i);  
            if (child.getVisibility() == VISIBLE) {  
                final ItemInfo ii = infoForChild(child);  
                if (ii != null && ii.position == mCurItem &&  
                        child.dispatchPopulateAccessibilityEvent(event)) {  
                    return true;  
                }  
            }  
        }  
  
        return false;  
    }  
  
    private class PagerObserver extends DataSetObserver {  
  
        @Override  
        public void onChanged() {  
            dataSetChanged();  
        }  
  
        @Override  
        public void onInvalidated() {  
            dataSetChanged();  
        }  
    }  
}
